home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / µSim 1.0.5 / FabLibsƒ / UtilsCommon.c < prev    next >
Encoding:
Text File  |  1995-11-28  |  44.3 KB  |  1,750 lines  |  [TEXT/CWIE]
  1. /*
  2. Copyright © 1993,1994 by Fabrizio Oddone
  3. ••• ••• ••• ••• ••• ••• ••• ••• ••• •••
  4. This source code is distributed as freeware: you can copy, exchange, modify this
  5. code as you wish. You may include this code in any kind of application: freeware,
  6. shareware, or commercial, provided that full credits are given.
  7. You may not sell or distribute this code for profit.
  8. */
  9.  
  10. //#pragma load "MacDump"
  11.  
  12. #include    "FabLibResIDs.h"
  13. #include    "Independents.h"
  14. #include    "MovableModal.h"
  15.  
  16. static void CommonCopyToClip(short id);
  17. static long RegisterStdConfigInfo(Handle regText, long curOffset, StringPtr tempS);
  18.  
  19. #if !(defined(powerc) || defined (__powerc)) || defined(FabSystem7orlater)
  20.  
  21. #if    !defined(FabNoSegmentDirectives)
  22. #pragma segment Main
  23. #endif
  24.  
  25. static AEEventHandlerUPP    gmyOAPP_UPP, gmyODOC_UPP, gmyPDOC_UPP, gmyQUIT_UPP;
  26.  
  27. #if defined(powerc) || defined (__powerc)
  28.  
  29. pascal StringPtr     PLstrcpy(StringPtr str1, ConstStr255Param str2)
  30. {
  31. BlockMoveData(str2, str1, StrLength(str2) + 1);
  32. return str1;
  33. }
  34.  
  35. pascal StringPtr     PLstrncpy(StringPtr str1, ConstStr255Param str2, short num)
  36. {
  37. BlockMoveData(str2, str1, 1 + MIN(StrLength(str2), num));
  38. return str1;
  39. }
  40.  
  41. pascal StringPtr    PLstrcat(StringPtr str1, ConstStr255Param str2)
  42. {
  43. BlockMoveData(str2 + 1, str1 + StrLength(str1) + 1, StrLength(str2));
  44. StrLength(str1) += StrLength(str2);
  45. return str1;
  46. }
  47.  
  48. pascal StringPtr    PLstrncat(StringPtr str1, ConstStr255Param str2, short num)
  49. {
  50. BlockMoveData(str2 + 1, str1 + StrLength(str1) + 1, MIN(num, StrLength(str2)));
  51. StrLength(str1) += StrLength(str2);
  52. return str1;
  53. }
  54.  
  55. void MyZeroBuffer(long *p, long s)
  56. {
  57. for ( ; s-- >= 0; *p++ = 0L);
  58. }
  59.  
  60. void MyFillBuffer(long *p, long s, long filler)
  61. {
  62. for ( ; s-- >= 0; *p++ = filler);
  63. }
  64.  
  65. long mySwap(long s)
  66. {
  67. long    t;
  68.  
  69. t = s >> 16;
  70. *(short *)&t = (short) s;
  71. return t;
  72. }
  73.  
  74. #endif
  75.  
  76. /* AddSTRRes2Doc: adds the standard 'STR ' resource
  77. to a newly saved document */
  78.  
  79. OSErr AddSTRRes2Doc(FSSpec *theDoc, OSType myFcrea, OSType myFtype, short STRid, ScriptCode lScript)
  80. {
  81. register Handle    msgString;
  82. register short    fRefn;
  83. register OSErr    err;
  84.  
  85. DetachResource(msgString = (Handle)GetString(STRid));
  86. FSpCreateResFileCompat(theDoc, myFcrea, myFtype, lScript);
  87. if ((err = ResError()) == noErr)
  88.     if ((fRefn = FSpOpenResFileCompat(theDoc, fsRdWrPerm)) == -1)
  89.         err = ResError();
  90.     else {
  91.         AddResource(msgString, 'STR ', STRid, "\p");
  92.         if ((err = ResError()) == noErr) {
  93.             SetResAttrs(msgString, GetResAttrs(msgString) | resPurgeable);
  94.             err = ResError();
  95.             }
  96.         else
  97.             DisposeHandle(msgString);
  98.         CloseResFile(fRefn);
  99.         }
  100. return err;
  101. }
  102.  
  103. /* AddSTRHand2Doc: adds the standard 'STR ' resource
  104. to a newly saved document */
  105.  
  106. OSErr AddSTRHand2Doc(FSSpec *theDoc, OSType myFcrea, OSType myFtype, StringHandle msgString, ScriptCode lScript)
  107. {
  108. register short    fRefn;
  109. register OSErr    err;
  110.  
  111. FSpCreateResFileCompat(theDoc, myFcrea, myFtype, lScript);
  112. if ((err = ResError()) == noErr)
  113.     if ((fRefn = FSpOpenResFileCompat(theDoc, fsRdWrPerm)) == -1)
  114.         err = ResError();
  115.     else {
  116.         AddResource((Handle)msgString, 'STR ', kSTR_ApplicationName, "\p");
  117.         if ((err = ResError()) == noErr) {
  118.             SetResAttrs((Handle)msgString, GetResAttrs((Handle)msgString) | resPurgeable);
  119.             err = ResError();
  120.             }
  121.         else
  122.             DisposeHandle((Handle)msgString);
  123.         CloseResFile(fRefn);
  124.         }
  125. return err;
  126. }
  127.  
  128. OSErr AddRes2Doc(FSSpec *theDoc, Handle thisHandle, ResType rType, short rID)
  129. {
  130. register Handle    existHandle;
  131. register short    fRefn;
  132. register OSErr    err;
  133.  
  134. if ((fRefn = FSpOpenResFileCompat(theDoc, fsRdWrPerm)) == -1)
  135.     err = ResError();
  136. else {
  137. //    if (noErr == (err = HandToHand(&thisHandle)))
  138.     SetResLoad(false);
  139.     existHandle = Get1Resource(rType, rID);
  140.     SetResLoad(true);
  141.     if (existHandle) {
  142.         RemoveResource(existHandle);
  143.         DisposeHandle(existHandle);
  144.         }
  145.     AddResource(thisHandle, rType, rID, "\p");
  146.     if ((err = ResError()) == noErr) {
  147.         SetResAttrs(thisHandle, GetResAttrs(thisHandle) | resPurgeable);
  148.         err = ResError();
  149.         }
  150.     CloseResFile(fRefn);
  151.     }
  152. return err;
  153. }
  154.  
  155. /* SendmyAE: we send an Apple Event with the specified ID to ourselves */
  156.  
  157. void SendmyAE(AEEventClass myclass, AEEventID myAEvtID, AEIdleProcPtr IdleFunct, AESendMode theMode)
  158. {
  159. AEIdleUPP    IdleFunctUPP = NewAEIdleProc(IdleFunct);
  160. AppleEvent    myAEvent;
  161. AppleEvent    myAEReply;
  162. AEAddressDesc    targetAddress;
  163. ProcessSerialNumber myPSN = { 0, kCurrentProcess };
  164. register OSErr    err;
  165.  
  166. if ((err = AECreateDesc(typeProcessSerialNumber, (Ptr)&myPSN, sizeof(ProcessSerialNumber),
  167.     &targetAddress)) == noErr) {
  168.     if ((err = AECreateAppleEvent(myclass, myAEvtID, &targetAddress,
  169.         kAutoGenerateReturnID, kAnyTransactionID, &myAEvent)) == noErr) {
  170.         err = AESend(&myAEvent, &myAEReply, theMode,
  171.             kAENormalPriority, kNoTimeOut, IdleFunctUPP, 0L);
  172.         (void)AEDisposeDesc(&myAEvent);
  173.         }
  174.     (void)AEDisposeDesc(&targetAddress);
  175.     }
  176. if (IdleFunctUPP)
  177.     DisposeRoutineDescriptor(IdleFunctUPP);
  178. }
  179.  
  180. /* SendmyAEPShort: we send an Apple Event with the specified ID to ourselves */
  181.  
  182. void SendmyAEPShort(AEEventClass myclass, AEEventID myAEvtID, AEIdleProcPtr IdleFunct, AESendMode theMode, short theAlert)
  183. {
  184. AEIdleUPP    IdleFunctUPP = NewAEIdleProc(IdleFunct);
  185. AppleEvent    myAEvent;
  186. AppleEvent    myAEReply;
  187. AEAddressDesc    targetAddress;
  188. ProcessSerialNumber myPSN = { 0, kCurrentProcess };
  189. register OSErr    err;
  190.  
  191. if ((err = AECreateDesc(typeProcessSerialNumber, (Ptr)&myPSN, sizeof(ProcessSerialNumber),
  192.     &targetAddress)) == noErr) {
  193.     if ((err = AECreateAppleEvent(myclass, myAEvtID, &targetAddress,
  194.         kAutoGenerateReturnID, kAnyTransactionID, &myAEvent)) == noErr) {
  195.  
  196.         if ((err = AEPutParamPtr(&myAEvent, keyDirectObject, typeShortInteger, (Ptr)&theAlert, sizeof(theAlert))) == noErr)
  197.             err = AESend(&myAEvent, &myAEReply, theMode,
  198.                 kAENormalPriority, kNoTimeOut, IdleFunctUPP, 0L);
  199.         (void)AEDisposeDesc(&myAEvent);
  200.         }
  201.     (void)AEDisposeDesc(&targetAddress);
  202.     }
  203. if (IdleFunctUPP)
  204.     DisposeRoutineDescriptor(IdleFunctUPP);
  205. }
  206.  
  207. /* ZoomRectToRect: draws zooming gray rectangles from startingRect to endingRect
  208. in the current port; numofDivs is the density of rectangles in the interval */
  209.  
  210. void ZoomRectToRect(RectPtr startingRect, RectPtr endingRect, short numofDivs)
  211. {
  212. PenState    curPen;
  213. Rect    trailingRect = { 0, 0, 0, 0 };
  214. Rect    tempRect;
  215. Handle    rectStorH;
  216. short    mtop, mleft, mbottom, mright;
  217. register long    ttopleft, tbotright;
  218. register short *spntr;
  219. register long *lpntr;
  220. register int    i, j, tsh;
  221.  
  222. if (numofDivs < (CHAR_BIT * sizeof(short))) {
  223.     if (rectStorH = NewHandleGeneral(numofDivs * sizeof(Rect))) {
  224.         GetPenState(&curPen);
  225.         PenPat(&qd.gray);
  226.         PenMode(patXor);
  227.         mtop = endingRect->top - startingRect->top;
  228.         mleft = endingRect->left - startingRect->left;
  229.         mbottom = endingRect->bottom - startingRect->bottom;
  230.         mright = endingRect->right - startingRect->right;
  231.         spntr = (short *)*rectStorH;
  232.         for (i = 1; i <= numofDivs; i++) {
  233.             *spntr++ = mtop >>= 1;
  234.             *spntr++ = mleft >>= 1;
  235.             *spntr++ = mbottom >>= 1;
  236.             *spntr++ = mright >>= 1;
  237.             }
  238.         HLock(rectStorH);
  239.         for (i = 1; i < (1 << numofDivs); i++) {
  240.             ttopleft = *(long *)startingRect;
  241.             tbotright = ((long *)startingRect)[1];
  242.             lpntr = (long *)*rectStorH;
  243.             tsh = i << ((CHAR_BIT * sizeof(short)) - numofDivs);
  244.             for (j = 1; j <= numofDivs; j++) {
  245.                 if (tsh < 0) {
  246.                     ttopleft += *lpntr++;
  247.                     tbotright += *lpntr++;
  248.                     }
  249.                 else
  250.                     lpntr += 2;
  251.                 tsh <<= 1;
  252.                 }
  253.             
  254.             *(long *)&tempRect = ttopleft;
  255.             ((long *)&tempRect)[1] = tbotright;
  256.             FrameRect(&tempRect);
  257.             FrameRect(&trailingRect);
  258.             trailingRect = tempRect;
  259.             }
  260.         FrameRect(&tempRect);
  261.         DisposeHandle(rectStorH);
  262.         SetPenState(&curPen);
  263.         }
  264.     }
  265. }
  266.  
  267. void ZoomRectToRectAutoGrafPort(RectPtr startingRect, RectPtr endingRect, short numofDivs)
  268. {
  269. GrafPtr        savePort;
  270. GrafPort    ZoomPort;
  271.  
  272. GetPort(&savePort);
  273. OpenPort(&ZoomPort);
  274. ZoomRectToRect(startingRect, endingRect, numofDivs);
  275. ClosePort(&ZoomPort);
  276. SetPort(savePort);
  277. }
  278.  
  279. /* NewHandleGeneral: makes a new handle in main or temporary memory, arguably
  280. in the more suitable heap zone */
  281.  
  282. Handle NewHandleGeneral(Size blockSize)
  283. {
  284. register Handle    myH;
  285. OSErr    err;
  286.  
  287. if (TempFreeMem() > FreeMem()) {
  288.     if ((myH = TempNewHandle(blockSize, &err)) == nil) {
  289.         ReserveMem(blockSize);
  290.         myH = NewHandle(blockSize);
  291.         }
  292.     }
  293. else {
  294.     ReserveMem(blockSize);
  295.     if ((myH = NewHandle(blockSize)) == nil)
  296.         myH = TempNewHandle(blockSize, &err);
  297.     }
  298. return(myH);
  299. }
  300.  
  301. /* Get1ResGeneral: like Get1Resource, but loads in main or temporary memory */
  302.  
  303. Handle Get1ResGeneral(ResType theType,short theID)
  304. {
  305. register Handle    emptyH, destH;
  306. register Size    myResSize;
  307.  
  308. SetResLoad(false);
  309. emptyH = Get1Resource(theType, theID);
  310. SetResLoad(true);
  311. destH = NewHandleGeneral(myResSize = GetResourceSizeOnDisk(emptyH));
  312. if (destH) {
  313.     HLock(destH);
  314.     ReadPartialResource(emptyH, 0L, *destH, myResSize);
  315.     HUnlock(destH);
  316.     }
  317. ReleaseResource(emptyH);
  318. return(destH);
  319. }
  320.  
  321. OSType FindFinderAtEaseProcess(ProcessSerialNumber *theProcess)
  322. {
  323. ProcessInfoRec infoRec;
  324. ProcessSerialNumber process = {0L, kNoProcess};
  325. register OSType    retVal = '????';
  326.  
  327. infoRec.processInfoLength = sizeof(ProcessInfoRec);
  328. infoRec.processName = nil;
  329. infoRec.processAppSpec = nil;
  330.  
  331. while (GetNextProcess(&process) == noErr) {
  332.     if (noErr == (GetProcessInformation(&process, &infoRec))) {
  333.         if ((infoRec.processType == (unsigned long)'FNDR') &&
  334.             ((infoRec.processSignature == 'MACS') || (infoRec.processSignature == 'mfdr'))) {
  335.             
  336.             retVal = infoRec.processSignature;
  337.             *theProcess = process;
  338.             break;
  339.             }
  340.         }
  341.     }
  342. return retVal;
  343. }
  344.  
  345. OSType FindFinderProcess(void)
  346. {
  347. ProcessInfoRec infoRec;
  348. ProcessSerialNumber process = {0, kNoProcess};
  349. register OSType    retVal = '????';
  350.  
  351. infoRec.processInfoLength = sizeof(ProcessInfoRec);
  352. infoRec.processName = nil;
  353. infoRec.processAppSpec = nil;
  354.  
  355. while (GetNextProcess(&process) == noErr) {
  356.     if (noErr == (GetProcessInformation(&process, &infoRec))) {
  357.         if ((infoRec.processType == (unsigned long)'FNDR') &&
  358.             (infoRec.processSignature == 'MACS')) {
  359.             
  360.             retVal = infoRec.processSignature;
  361.             break;
  362.             }
  363.         }
  364.     }
  365. return retVal;
  366. }
  367.  
  368. /* SendShutdownToFinder: we tell the Finder (or At Ease) to Shutdown (!) */
  369.  
  370. OSErr SendShutdownToFinder(AEIdleProcPtr myIdleFunct, Boolean wantShutDown)
  371. {
  372. AEIdleUPP    myIdleFunctUPP = NewAEIdleProc(myIdleFunct);
  373. AppleEvent    myAEvent;
  374. AppleEvent    myAEReply;
  375. ProcessSerialNumber    process;
  376. AEAddressDesc    targetAddress;
  377. OSType    WantedCreator;
  378. register OSErr    err = errAEDescNotFound;
  379.  
  380. WantedCreator = FindFinderAtEaseProcess(&process);
  381. if ('????' != WantedCreator)
  382.     if ((err = AECreateDesc(typeApplSignature, (Ptr)&WantedCreator, sizeof(OSType),
  383.         &targetAddress)) == noErr) {
  384.         if ((err = AECreateAppleEvent(kAEFinderEvents, wantShutDown ? kAEShutDown : kAERestart , &targetAddress,
  385.             kAutoGenerateReturnID, kAnyTransactionID, &myAEvent)) == noErr) {
  386.             err = AESend(&myAEvent, &myAEReply, kAENoReply | kAEAlwaysInteract,
  387.                 kAENormalPriority, kNoTimeOut, myIdleFunctUPP, nil);
  388.             (void)AEDisposeDesc(&myAEvent);
  389.             if (err == noErr)
  390.                 (void)SetFrontProcess(&process);
  391.             }
  392.         (void)AEDisposeDesc(&targetAddress);
  393.         }
  394. if (myIdleFunctUPP)
  395.     DisposeRoutineDescriptor(myIdleFunctUPP);
  396. return err;
  397. }
  398.  
  399. short StopAlert_UPP(short alertID, ModalFilterProcPtr filterProc)
  400. {
  401. ModalFilterUPP    filterProcUPP = nil;
  402. register short    butHit;
  403.  
  404. if (filterProc)
  405.     filterProcUPP = NewModalFilterProc(filterProc);
  406. InitCursor();
  407. butHit = StopAlert(alertID, filterProcUPP);
  408. if (filterProcUPP)
  409.     DisposeRoutineDescriptor(filterProcUPP);
  410. return butHit;
  411. }
  412.  
  413. short StopAlert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  414. {
  415.  
  416. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  417. return StopAlert_UPP(alertID, filterProc);
  418. }
  419.  
  420. short CautionAlert_UPP(short alertID, ModalFilterProcPtr filterProc)
  421. {
  422. ModalFilterUPP    filterProcUPP = nil;
  423. register short    butHit;
  424.  
  425. if (filterProc)
  426.     filterProcUPP = NewModalFilterProc(filterProc);
  427. InitCursor();
  428. butHit = CautionAlert(alertID, filterProcUPP);
  429. if (filterProcUPP)
  430.     DisposeRoutineDescriptor(filterProcUPP);
  431. return butHit;
  432. }
  433.  
  434. short CautionAlert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  435. {
  436.  
  437. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  438. return CautionAlert_UPP(alertID, filterProc);
  439. }
  440.  
  441. short NoteAlert_UPP(short alertID, ModalFilterProcPtr filterProc)
  442. {
  443. ModalFilterUPP    filterProcUPP = nil;
  444. register short    butHit;
  445.  
  446. if (filterProc)
  447.     filterProcUPP = NewModalFilterProc(filterProc);
  448. InitCursor();
  449. butHit = NoteAlert(alertID, filterProcUPP);
  450. if (filterProcUPP)
  451.     DisposeRoutineDescriptor(filterProcUPP);
  452. return butHit;
  453. }
  454.  
  455. short NoteAlert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  456. {
  457.  
  458. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  459. return NoteAlert_UPP(alertID, filterProc);
  460. }
  461.  
  462. short Alert_UPP(short alertID, ModalFilterProcPtr filterProc)
  463. {
  464. ModalFilterUPP    filterProcUPP = nil;
  465. register short    butHit;
  466.  
  467. if (filterProc)
  468.     filterProcUPP = NewModalFilterProc(filterProc);
  469. InitCursor();
  470. butHit = Alert(alertID, filterProcUPP);
  471. if (filterProcUPP)
  472.     DisposeRoutineDescriptor(filterProcUPP);
  473. return butHit;
  474. }
  475.  
  476. short Alert_AE(short alertID, ModalFilterProcPtr filterProc, AEIdleProcPtr IdleFunct)
  477. {
  478.  
  479. SendmyAE(kCreat, kAEAlert, IdleFunct, kAENoReply | kAEAlwaysInteract);
  480. return Alert_UPP(alertID, filterProc);
  481. }
  482.  
  483. /* my Dialog box manager */
  484.  
  485. void FlashButton(DialogPtr dlg, short item)
  486. {
  487. Rect    txtBox;
  488. ControlHandle    itH;
  489. long    dummy;
  490. short    typ;
  491.  
  492. GetDialogItem(dlg, item, &typ, (Handle *)&itH, &txtBox);
  493. HiliteControl(itH, 1);
  494. Delay(4L, &dummy);
  495. HiliteControl(itH, 0);
  496. }
  497.  
  498. static void FrameRoundBW(const RectPtr theRect, ConstPatternParam bpat, short ovalP);
  499.  
  500. enum {
  501. kIsColorPort = 0xC000,
  502. kButtonFrameSize = 3,    /* button frame's pen size */
  503. kButtonFrameInset = -4    /* inset rectangle adjustment around button */
  504. };
  505.  
  506. void OutlineButton(DialogPtr oftheDialog, short myItem)
  507. {
  508. RGBColor    foreCol, backCol, savedForeCol;
  509. PenState    curPen;
  510. PatPtr    thePat;
  511. GrafPtr    savePort;
  512. Rect    txtBox;
  513. Handle    itH;
  514. short    typ;
  515.  
  516. GetDialogItem(oftheDialog, myItem, &typ, &itH, &txtBox);
  517. GetPort(&savePort);
  518. SetGrafPortOfDialog(oftheDialog);
  519.  
  520. InsetRect(&txtBox, kButtonFrameInset, kButtonFrameInset);
  521. typ = ((txtBox.bottom - txtBox.top) >> 1) + 2;
  522.  
  523. thePat = (*(ControlHandle)itH)->contrlHilite == 0 ? &qd.black : &qd.gray;
  524.  
  525. GetPenState(&curPen);
  526. PenNormal();
  527. PenSize(kButtonFrameSize, kButtonFrameSize);
  528. if ((((CGrafPtr)(*(ControlHandle)itH)->contrlOwner)->portVersion & kIsColorPort) == kIsColorPort) {
  529.     if ((*(ControlHandle)itH)->contrlHilite) {
  530.         GetForeColor(&foreCol);
  531.         savedForeCol = foreCol;
  532.         GetBackColor(&backCol);
  533.         if (GetGray(GetGDevice(), &backCol, &foreCol)) {
  534.             RGBForeColor(&foreCol);
  535.             FrameRoundRect(&txtBox, typ, typ);
  536.             RGBForeColor(&savedForeCol);
  537.             }
  538.         else
  539.             FrameRoundBW(&txtBox, thePat, typ);
  540.         }
  541.     else
  542.         FrameRoundRect(&txtBox, typ, typ);
  543.     }
  544. else {
  545.     FrameRoundBW(&txtBox, thePat, typ);
  546.     }
  547.  
  548. SetPenState(&curPen);
  549. SetPort(savePort);
  550. }
  551.  
  552. void FrameRoundBW(const RectPtr theRect, ConstPatternParam bpat, short ovalP)
  553. {
  554. PenPat(bpat);
  555. FrameRoundRect(theRect, ovalP, ovalP);
  556. }
  557.  
  558. short HandleDialog(ModalFilterProcPtr filterProc,
  559.                     dialogItemsPtr things,
  560.                     void (*initProc)(DialogPtr),
  561.                     void (*userProc)(DialogPtr, Handle, short),
  562.                     short resId)
  563. {
  564. ModalFilterUPP    filterProcUPP = NewModalFilterProc(filterProc);
  565. Rect    box;
  566. Handle    item;
  567. GrafPtr    port;
  568. register long    myRefCon;
  569. register DialogPtr    dPtr;
  570. register dialogItemsPtr    spanPtr;
  571. dialogItemsPtr    itemToBeActivated;
  572. short    type, theItemHit = memFullErr;
  573. short    theGroup, lastItemClosingDialog = cancel;
  574. register short    theType, iNum;
  575. register Boolean    editTextExists = false;
  576. Boolean    dialoging;
  577. #if !defined(FabSystem7orlater)
  578. long    Gresp;
  579. Boolean    dialogManager7Present = false;
  580. #endif
  581.  
  582. InitCursor();
  583. dPtr = GetNewDialog(resId, nil, (WindowRef)-1L);
  584. if (dPtr) {
  585.     GetPort(&port);
  586.     SetGrafPortOfDialog(dPtr);
  587.  
  588. #if !defined(FabSystem7orlater)
  589.     if (Gestalt(gestaltDITLExtAttr, &Gresp) == noErr)
  590.         if (Gresp & (1L << gestaltDITLExtPresent))
  591.             dialogManager7Present = true;
  592. #endif
  593.  
  594. #pragma mark Setup
  595.     
  596.     spanPtr = things;
  597.     while (iNum = spanPtr->itemNumber) {
  598.         myRefCon = spanPtr->refCon;
  599.         GetDialogItem(dPtr, iNum, &type, &item, &box);
  600.         theType = type & itemDisable ? type - itemDisable : type;
  601.         switch(theType) {
  602.             case ctrlItem+btnCtrl:
  603. #if !defined(FabSystem7orlater)
  604.                 if (dialogManager7Present)
  605. #endif
  606.                     {
  607.                     if (myRefCon == 1L)
  608.                         (void) SetDialogDefaultItem(dPtr, iNum);
  609.                     else if (myRefCon == 2L)
  610.                         lastItemClosingDialog = iNum;
  611.                     if (iNum == cancel)
  612.                         (void) SetDialogCancelItem(dPtr, iNum);
  613.                     }
  614.                 break;
  615.             case ctrlItem+chkCtrl:
  616.             case ctrlItem+radCtrl:
  617.                 if (myRefCon > 0) {
  618.                     SetControlValue((ControlHandle)item, 1);
  619.                     if (userProc)
  620.                         userProc(dPtr, item, iNum);
  621.                     }
  622. /*                else if (myRefCon == 0) {
  623.                     if (userProc)
  624.                         userProc(dPtr, item, iNum);
  625.                     }*/
  626.                 else if (myRefCon < 0)
  627.                     HiliteControl((ControlHandle)item, 255);
  628.                 break;
  629.             case ctrlItem+resCtrl:
  630.                 if (myRefCon)
  631.                     SetControlValue((ControlHandle)item, myRefCon);
  632.                 break;
  633.             case statText:
  634.                 if (myRefCon)
  635.                     SetDialogItemText(item, (StringPtr)myRefCon);
  636.                 break;
  637.             case editText:
  638.                 SetDialogItemText(item, (StringPtr)myRefCon);
  639.                 if(editTextExists == false) {
  640.                     SelectDialogItemText(dPtr, iNum, 0, SHRT_MAX);
  641.                     editTextExists = true;
  642.                     }
  643.                 break;
  644.     //        case iconItem:
  645.     //            break;
  646.     //        case picItem:
  647.     //            break;
  648.             case userItem:
  649.                 SetDialogItem(dPtr, iNum, type, (Handle)myRefCon, &box);
  650.                 break;
  651.             }
  652.         spanPtr++;
  653.         }
  654. #if !defined(FabSystem7orlater)
  655.     if (dialogManager7Present)
  656. #endif
  657.         (void) SetDialogTracksCursor(dPtr, editTextExists);
  658.     if (initProc)
  659.         initProc(dPtr);
  660.     ShowWindow(GetDialogWindow(dPtr));
  661.     
  662. #pragma mark Event Loop
  663.     
  664.     dialoging = true;
  665.     do {
  666.         ModalDialog(filterProcUPP, &theItemHit);
  667.         if (theItemHit) {
  668.             GetDialogItem(dPtr, theItemHit, &type, &item, &box);
  669.             switch (type) {
  670.                 case ctrlItem+btnCtrl:
  671.                     if ((theItemHit >= ok) && (theItemHit <= lastItemClosingDialog))
  672.                         dialoging = false;
  673.                     else if (userProc)
  674.                         userProc(dPtr, item, theItemHit);
  675.                     break;
  676.                 case ctrlItem+chkCtrl:
  677.                     SetControlValue((ControlHandle)item, 1 - GetControlValue((ControlHandle)item));
  678.                     if (userProc)
  679.                         userProc(dPtr, item, theItemHit);
  680.                     break;
  681.                 case ctrlItem+radCtrl:
  682.                     if (GetControlValue((ControlHandle)item) == 0) {
  683.                         SetControlValue((ControlHandle)item, 1);
  684.                         for (spanPtr = things; (++spanPtr)->itemNumber != theItemHit; )
  685.                             ;
  686.                         itemToBeActivated = spanPtr;
  687.                         for (theGroup = spanPtr->group; (--spanPtr)->group == theGroup; )
  688.                             ;
  689.                         while ((++spanPtr)->refCon <= 0L)
  690.                             ;
  691.                         GetDialogItem(dPtr, spanPtr->itemNumber, &type, &item, &box);
  692.                         SetControlValue((ControlHandle)item, 0);
  693.                         spanPtr->refCon = 0L;
  694.                         itemToBeActivated->refCon = 1L;
  695.                         if (userProc)
  696.                             userProc(dPtr, item, theItemHit);
  697.                         }
  698.                     break;
  699.                 case ctrlItem+resCtrl:
  700.                 case editText:
  701.                     if (userProc)
  702.                         userProc(dPtr, item, theItemHit);
  703.                     break;
  704.                 }
  705.             }
  706.         }
  707.     while (dialoging);
  708.     
  709. #pragma mark Return Settings
  710.     
  711.     if (theItemHit == ok) {
  712.         spanPtr = things;
  713.         while (iNum = spanPtr->itemNumber) {
  714.             GetDialogItem(dPtr, iNum, &type, &item, &box);
  715.             theType = type & itemDisable ? type - itemDisable : type;
  716.             switch(theType) {
  717.                 case ctrlItem+chkCtrl:
  718.                 case ctrlItem+resCtrl:
  719.                     spanPtr->refCon = GetControlValue((ControlHandle)item);
  720.                     break;
  721.                 case editText:
  722.                     GetDialogItemText(item, (StringPtr)spanPtr->refCon);
  723.                     break;
  724.         //        case iconItem:
  725.         //            break;
  726.         //        case picItem:
  727.         //            break;
  728.         //        case userItem:
  729.         //            break;
  730.                 }
  731.             spanPtr++;
  732.             }
  733.         }
  734.     DisposeDialog(dPtr);
  735.     SetPort(port);
  736.     }
  737. else
  738.     SysBeep(30);
  739. if (filterProcUPP)
  740.     DisposeRoutineDescriptor(filterProcUPP);
  741. InitCursor();
  742. return theItemHit;
  743. }
  744.  
  745. /* About box manager */
  746.  
  747. #if    !defined(FabNoSegmentDirectives)
  748. #pragma segment About
  749. #endif
  750.  
  751. /* myAbout: the events directed against the about box are checked with
  752. EventAvail, so that we can discard the about box and process
  753. important events later in the main event loop */
  754.  
  755. void myAbout(void (*theIdleProc)(void),
  756.             UserItemUPP DrawQTPict,
  757.             void (*UpdateProc)(EventRecord *),
  758.             void (*ActivateProc)(EventRecord *)
  759.             )
  760. {
  761. EventRecord    evrec;
  762. DialogPtr    agh, dPtr;
  763. short    iHit;
  764. register Handle    splash;
  765. register Boolean    exit = false;
  766.  
  767. splash = OpenSplash(&agh, DrawQTPict);
  768. if (splash) {
  769.     ShowWindow(GetDialogWindow(agh));
  770.     do {
  771.         SystemTask();
  772.         if (EventAvail(everyEvent, &evrec)) {
  773.             switch(evrec.what) {
  774.                 case mouseDown:
  775.                 case keyDown:
  776.                 case autoKey:
  777.                     exit = true;
  778.                     FlushEvents(mDownMask | mUpMask | keyDownMask | autoKeyMask, 0);
  779.                     break;
  780.                 case mouseUp:
  781.                     (void)GetNextEvent(mUpMask, &evrec);
  782.                     break;
  783.                 case updateEvt :
  784.                     (void)GetNextEvent(updateMask, &evrec);
  785.                     if ((DialogPtr)evrec.message == agh) {
  786.                         BeginUpdate(GetDialogWindow(agh));
  787.                         UpdateDialog(agh, agh->visRgn);
  788.                         EndUpdate(GetDialogWindow(agh));
  789.                         }
  790.                     else
  791.                         if (IsDialogEvent(&evrec))
  792.                             (void) DialogSelect(&evrec, &dPtr, &iHit);
  793.                         else
  794.                             UpdateProc(&evrec);
  795.                     break;
  796.                 case diskEvt :
  797.                 case osEvt :
  798.                 case kHighLevelEvent:
  799.                     exit = true;
  800.                     break;
  801.                 case activateEvt :
  802.                     (void)GetNextEvent(activMask, &evrec);
  803.                     if ((DialogPtr)evrec.message != agh) {
  804.                         if (IsDialogEvent(&evrec))
  805.                             (void) DialogSelect(&evrec, &dPtr, &iHit);
  806.                         else
  807.                             ActivateProc(&evrec);
  808.                         }
  809.                     break;
  810. //                case driverEvt :
  811. //                    (void)GetNextEvent(driverMask, &evrec);
  812. //                    break;
  813.                 }
  814.             }
  815.         else {
  816.             theIdleProc();
  817.             }
  818.         }
  819.     while (exit == false);
  820.     DisposeSplash(splash, agh);
  821.     }
  822. else
  823.     SysBeep(30);
  824. }
  825.  
  826. /* OpenSplash: puts up the about window */
  827.  
  828. Handle OpenSplash(DialogPtr *pass, UserItemUPP DrawQTPict)
  829. {
  830. enum {
  831. kDLOG_About = 256,
  832. kItemPICT = 1
  833. };
  834.  
  835. Str15    tempS = "\p";
  836. Rect    box;
  837. register DialogPtr    dPtr;
  838. register VersRecHndl    myvers;
  839. register Handle    hand;
  840. Handle    item;
  841. short    type;
  842.  
  843. hand = NewHandle(sizeof(DialogRecord));
  844. if (hand) {
  845.     HLockHi(hand);
  846.     myvers = (VersRecHndl)Get1Resource('vers', 1);
  847.     if (myvers) {
  848.         (void) PLstrncpy(tempS, (*myvers)->shortVersion, 15);
  849.         ReleaseResource((Handle)myvers);
  850.         }
  851.     else
  852.         tempS[0] = 0;
  853.     ParamText((ConstStr255Param)&tempS, nil, nil, nil);
  854.     *pass = dPtr = GetNewDialog(kDLOG_About, *hand, (WindowRef)-1L);
  855.     if (dPtr) {
  856.         if (DrawQTPict) {
  857.             GetDialogItem(dPtr, kItemPICT, &type, &item, &box);
  858.             SetDialogItem(dPtr, kItemPICT, type, (Handle)DrawQTPict, &box);
  859.             }
  860.         }
  861.     else {
  862.         DisposeHandle(hand);
  863.         hand = nil;
  864.         }
  865.     }
  866. return(hand);
  867. }
  868.  
  869. /* DisposeSplash: gets rid of the about window */
  870.  
  871. void DisposeSplash(Handle dialog, DialogPtr pass)
  872. {
  873. CloseDialog(pass);
  874. DisposeHandle(dialog);
  875. }
  876.  
  877. void myMovableModalAbout(
  878.             Point *aboutTopLeft,
  879.             Point *creditsTopLeft,
  880.             void (*AdjustMenus)(TEHandle),
  881.             void (*Handle_My_Menu)(long),
  882.             void (*DomyKeyEvent)(EventRecord *),
  883.             void (*DoUpdate)(EventRecord *),
  884.             void (*DoActivate)(EventRecord *),
  885.             void (*DoHiLevEvent)(EventRecord *),
  886.             void (*DoOSEvent)(EventRecord *),
  887.             void (*DoIdle)(void),
  888.             unsigned long minSleep
  889.             )
  890. {
  891. Str15    tempS = "\p";
  892. dialogItems    things[] = {{ ok, 0, 1L },
  893.                         { cancel, 0, 0L },
  894.                         { 0, 0, 0L}
  895.                         };
  896. dialogItems    credits[] = {{ ok, 0, 1L },
  897.                         { 0, 0, 0L}
  898.                         };
  899. register VersRecHndl    myvers;
  900.  
  901. myvers = (VersRecHndl)Get1Resource('vers', 1);
  902. if (myvers) {
  903.     (void) PLstrncpy(tempS, (*myvers)->shortVersion, 15);
  904.     ReleaseResource((Handle)myvers);
  905.     }
  906. else
  907.     tempS[0] = 0;
  908. ParamText((ConstStr255Param)&tempS, nil, nil, nil);
  909. switch (HandleMovableModalDialog((dialogItemsPtr)&things, aboutTopLeft, nil, nil, nil, nil, nil,
  910.             AdjustMenus,
  911.             Handle_My_Menu,
  912.             DomyKeyEvent,
  913.             nil,
  914.             nil,
  915.             DoUpdate,
  916.             DoActivate,
  917.             DoHiLevEvent,
  918.             DoOSEvent,
  919.             DoIdle,
  920.             minSleep,
  921.             kDLOG_MovableAbout)) {
  922.     case ok:
  923.         break;
  924.     case cancel:
  925.         (void) HandleMovableModalDialog((dialogItemsPtr)&credits, creditsTopLeft, nil, nil, nil, nil, nil,
  926.             AdjustMenus,
  927.             Handle_My_Menu,
  928.             DomyKeyEvent,
  929.             nil,
  930.             nil,
  931.             DoUpdate,
  932.             DoActivate,
  933.             DoHiLevEvent,
  934.             DoOSEvent,
  935.             DoIdle,
  936.             minSleep,
  937.             kDLOG_MovableCredits);
  938.         break;
  939.     }
  940. }
  941.  
  942. #if    !defined(FabNoSegmentDirectives)
  943. #pragma segment Main
  944. #endif
  945.  
  946. #if defined(powerc) || defined (__powerc)
  947. SignedByte WantThisHandleSafe(Handle myH)
  948. {
  949. SignedByte    cMemTags;
  950.  
  951. cMemTags = HGetState(myH);
  952. HLockHi(myH);
  953. return cMemTags;
  954. }
  955.  
  956. #endif
  957.  
  958.  
  959. void CopyEMailAddrToClip(void)
  960. {
  961. CommonCopyToClip(kSTR_EMAILADDR);
  962. }
  963.  
  964. void CopyWWWURLToClip(short menuItem)
  965. {
  966. CommonCopyToClip(kSTR_WWWURLITA - 1 + menuItem);
  967. }
  968.  
  969. void CommonCopyToClip(short id)
  970. {
  971. StringHandle    theStr;
  972.  
  973. if (theStr = GetString(id)) {
  974.     if (noErr == ZeroScrap()) {
  975.         HLockHi((Handle)theStr);
  976.         (void) PutScrap(**theStr, 'TEXT', *theStr + 1);
  977.         HUnlock((Handle)theStr);
  978.         }
  979.     (void)TEFromScrap();
  980.     }
  981. }
  982.  
  983. /* GetFontNumber: gets font number from font name */
  984.  
  985. Boolean GetFontNumber(ConstStr255Param fontName, short *fontNum)
  986. {
  987. Str255    systemFontName;
  988. register Boolean    retFlag;
  989.  
  990. GetFNum(fontName, fontNum);
  991. if ((retFlag = (*fontNum != 0)) == false) {
  992.     GetFontName(0, systemFontName);
  993.     retFlag = EqualString(fontName, systemFontName, false, false);
  994.     }
  995. return retFlag;
  996. }
  997.  
  998. /* this is taken from "Macintosh Programming Secrets"
  999. by Scott Knaster & Keith Rollin;
  1000. optimization by Fabrizio Oddone */
  1001.  
  1002. Boolean CmdPeriod(EventRecord *theEvent)
  1003. {
  1004. #define    kModifiersMask    (0xFF00 & ~cmdKey)
  1005.  
  1006. Handle    hKCHR;
  1007. UInt32    state;
  1008. long    /*virtualKey, */keyInfo, keyCID;
  1009. UInt16    keyCode;
  1010. Boolean    result = false;
  1011.  
  1012. if ((theEvent->what == keyDown) || (theEvent->what == autoKey)) {
  1013.     if (theEvent->modifiers & cmdKey) {
  1014. //        virtualKey = (theEvent->message >> 8) >> 8;
  1015.         keyCode = (theEvent->modifiers & kModifiersMask) | ((unsigned short)theEvent->message >> 8);
  1016.         state = 0;
  1017.         keyCID = GetScriptVariable(GetScriptManagerVariable(smKeyScript), smScriptKeys);
  1018.         hKCHR = GetResource('KCHR', keyCID);
  1019.         if (hKCHR) {
  1020.             keyInfo = KeyTranslate(*hKCHR, keyCode, &state);
  1021.             ReleaseResource(hKCHR);
  1022.             }
  1023.         else
  1024.             keyInfo = theEvent->message;
  1025.         
  1026.         if (((char)keyInfo == '.') || ((char)(keyInfo >> 16) == '.'))
  1027.             result = true;
  1028.         }
  1029.     }
  1030.  
  1031. return result;
  1032. }
  1033.  
  1034. /* other useful stuff to detect keypresses */
  1035.  
  1036. Boolean CmdPeriodOrEsc(EventRecord *theEvent)
  1037. {
  1038. return ((unsigned short)theEvent->message == kEscapeKey) || CmdPeriod(theEvent);
  1039. }
  1040.  
  1041. Boolean CmdPeriodOrEscConfirm(EventRecord *theEvent, short alertID, ModalFilterProcPtr filterProc)
  1042. {
  1043. register Boolean    retflag;
  1044.  
  1045. retflag = CmdPeriodOrEsc(theEvent);
  1046. if (retflag) {
  1047.     ModalFilterUPP    filterProcUPP = NewModalFilterProc(filterProc);
  1048.     
  1049.     InitCursor();
  1050.     retflag = CautionAlert(alertID, filterProcUPP) == cancel;
  1051.     if (filterProcUPP)
  1052.         DisposeRoutineDescriptor(filterProcUPP);
  1053.     }
  1054.  
  1055. return retflag;
  1056. }
  1057.  
  1058. #if    !defined(FabNoSegmentDirectives)
  1059. #pragma segment Registration
  1060. #endif
  1061.  
  1062. short gHowManyDollars;
  1063.  
  1064. /* RegistrationFilter: the filter filters entered characters, of course */
  1065.  
  1066. static void RegInitProc(DialogPtr myDPtr);
  1067. static Boolean RegistrationPreProcessKey(EventRecord *thEv, DialogPtr theD);
  1068. static void RegistrationPostProcessKey(EventRecord *thEv, DialogPtr theD);
  1069.  
  1070. Boolean RegistrationPreProcessKey(EventRecord *thEv, DialogPtr theD)
  1071. {
  1072. enum {
  1073. //kBackspaceKey = 8,
  1074. kMaxCopiesChars = 8
  1075. };
  1076.  
  1077. Str255    tempStr;
  1078. Rect    tempRect;
  1079. Handle    ih;
  1080. //short    theItem = GetDialogKeyboardFocusItem(theD);
  1081. short    null;
  1082. short    iHit;
  1083. unsigned char    keypressed;
  1084. Boolean    result = true;
  1085.  
  1086. keypressed = CHARFROMMESSAGE(thEv->message);
  1087. iHit = GetDialogKeyboardFocusItem(theD);
  1088. if (iHit == kItemQuantity) {
  1089.     if (keypressed >= 32 && ((thEv->modifiers & cmdKey) == 0)) {
  1090.         result = ( Munger((Handle)GetString(kSTR_RegDECALLOWED), 1L,
  1091.                         &keypressed, 1L, 0L, 0L) >= 0L );
  1092.         if (result) {
  1093.             GetDialogItem(theD, iHit, &null, &ih, &tempRect);
  1094.             GetDialogItemText(ih, tempStr);
  1095.             if (StrLength(tempStr) >= kMaxCopiesChars) {
  1096.                 (void)StopAlert_UPP(kALRT_WOWTHATMANYCOPIES, nil);
  1097.                 result = false;
  1098.                 }
  1099.             }
  1100.         }
  1101.     }
  1102. return result;
  1103. }
  1104.  
  1105. void RegistrationPostProcessKey(EventRecord */*thEv*/, DialogPtr theD)
  1106. {
  1107. short    theItem = GetDialogKeyboardFocusItem(theD);
  1108.  
  1109. if (theItem == kItemQuantity)
  1110.     RegInitProc(theD);
  1111. }
  1112.  
  1113. void HandleRegistration(/*ModalFilterProcPtr filterProc,*/
  1114.                         Point *regDTopLeft,
  1115.                         long (*regCfgInfo)(Handle, long, StringPtr),
  1116.                         void (*AdjustMenus)(TEHandle),
  1117.                         void (*Handle_My_Menu)(long),
  1118.                         void (*DomyKeyEvent)(EventRecord *),
  1119.                         void (*DoUpdate)(EventRecord *),
  1120.                         void (*DoActivate)(EventRecord *),
  1121.                         void (*DoHiLevEvent)(EventRecord *),
  1122.                         void (*DoOSEvent)(EventRecord *),
  1123.                         void (*DoIdle)(void),
  1124.                         unsigned long minSleep,
  1125.                         short howManyDollars)
  1126. {
  1127. enum {
  1128. kNumStrings = 13,
  1129. kMyRegText = 256
  1130. };
  1131.  
  1132. StringPtr    regInfo[kNumStrings];
  1133. StdFileResult    theChosenFile;
  1134. ParamBlockRec    myPB;
  1135. EventRecord    dummyEv;
  1136. Str63    tempS = "\p";
  1137. long    gResp;
  1138. short    tmpFRefN;
  1139. const short    zero = 0x0130;
  1140. const short    dash = 0x012D;
  1141. const char    optspace = 'Δ';
  1142. Handle    regText;
  1143. VersRecHndl    myvers;
  1144. StringHandle    sh;
  1145. StringPtr    myAppName = nil;
  1146. long    lOffset;
  1147. int    i;
  1148. OSErr    err;
  1149. SignedByte    savedState;
  1150.  
  1151. dialogItems    things[] = {{ ok, 0, 0L },
  1152.                         { cancel, 0, 0L },
  1153.                         { kItemUserName, 0, 0L },
  1154.                         { kItemCompany, 0, 0L },
  1155.                         { kItemAddress, 0, 0L },
  1156.                         { kItemCity, 0, 0L },
  1157.                         { kItemState, 0, 0L },
  1158.                         { kItemZIP, 0, 0L },
  1159.                         { kItemCountry, 0, 0L },
  1160.                         { kItemE_mail, 0, 0L },
  1161.                         { kItemPhone, 0, 0L },
  1162.                         { kItemFAX, 0, 0L },
  1163.                         { kItemQuantity, 0, 0L },
  1164.                         { kItemCopyFrom, 0, 0L },
  1165.                         { kItemComments, 0, 0L },
  1166.                         { 0, 0, 0L}
  1167.                         };
  1168.  
  1169. lOffset = (long)NewPtrClear(kNumStrings * sizeof(Str255));
  1170. if (lOffset) {
  1171.     things[kItemUserName-1].refCon = lOffset;
  1172.     regInfo[0] = (StringPtr)lOffset;
  1173.     lOffset += (kNumStrings - 1) * sizeof(Str255);
  1174.     for (i = kItemComments - 1; i >= kItemCompany - 1; i--, lOffset -= sizeof(Str255)) {
  1175.         things[i].refCon = lOffset;
  1176.         regInfo[i-2] = (StringPtr)lOffset;
  1177.         }
  1178.     
  1179.     (void)PLstrcpy((StringPtr)things[kItemQuantity-1].refCon, "\p2");
  1180.     
  1181.     gHowManyDollars = howManyDollars;
  1182.     sh = GetString(kSTR_ApplicationName);
  1183.     if (sh) {
  1184.         savedState = WantThisHandleSafe((Handle)sh);
  1185.         myAppName = *sh;
  1186.         }
  1187.     
  1188.     ParamText(myAppName, (ConstStr255Param)&zero, (ConstStr255Param)&zero, nil);
  1189.     if (sh)
  1190.         HSetState((Handle)sh, savedState);
  1191.     do
  1192.         if (HandleMovableModalDialog((dialogItemsPtr)&things, regDTopLeft, nil, nil, RegInitProc, nil, nil,
  1193.                 AdjustMenus,
  1194.                 Handle_My_Menu,
  1195.                 DomyKeyEvent,
  1196.                 RegistrationPreProcessKey,
  1197.                 RegistrationPostProcessKey,
  1198.                 DoUpdate,
  1199.                 DoActivate,
  1200.                 DoHiLevEvent,
  1201.                 DoOSEvent,
  1202.                 DoIdle,
  1203.                 minSleep,
  1204.                 kDLOG_Register) == ok)
  1205.             do {
  1206.                 if ((err = AskForDestFile(&theChosenFile, nil, nil)) == dupFNErr) {
  1207.                     InitCursor();
  1208.                     (void)StopAlert(kALRT_REGCANNOTREPLACE, nil);
  1209.                     }
  1210.                 }
  1211.             while (err == dupFNErr);
  1212.         else
  1213.             err = dupFNErr;
  1214.     while (err == userCanceledErr);
  1215.     if (err == noErr) {
  1216.         regText = Get1Resource('TEXT', kMyRegText);
  1217.         if (regText) {
  1218.             DetachResource(regText);
  1219.             myvers = (VersRecHndl)Get1Resource('vers', 1);
  1220.             if (myvers) {
  1221.                 (void) PLstrcpy(tempS, (*myvers)->shortVersion);
  1222.                 ReleaseResource((Handle)myvers);
  1223.                 }
  1224.             lOffset = Munger(regText, 0L, &optspace, 1L, &tempS[1], tempS[0]);
  1225.             for (i = kItemUserName-3; i <= kItemFAX-3; i++)
  1226.                 lOffset = Munger(regText, lOffset, &optspace, 1L, ®Info[i][1], regInfo[i][0]);
  1227.             for (i = kItemCopyFrom-3; i <= kItemComments-3; i++)
  1228.                 lOffset = Munger(regText, lOffset, &optspace, 1L, ®Info[i][1], regInfo[i][0]);
  1229.             
  1230.             lOffset = RegisterStdConfigInfo(regText, lOffset, tempS);
  1231.             /* custom configuration */
  1232.             if (regCfgInfo)
  1233.                 lOffset = regCfgInfo(regText, lOffset, tempS);
  1234.             
  1235.             /* quantity */
  1236.             lOffset = Munger(regText, lOffset, &optspace, 1L, ®Info[kItemQuantity-3][1], regInfo[kItemQuantity-3][0]);
  1237.             StringToNum(regInfo[kItemQuantity-3], &gResp);
  1238.             MyNumToString(howManyDollars * sqrt(gResp), tempS);
  1239.     //        UnloadSeg(sqrt);
  1240.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1241.             IUDateString(LMGetTime(), longDate, tempS);
  1242.             lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1243. // 6
  1244.             if ((err = FSpCreateCompat(&theChosenFile.destFile, 'ttxt', 'TEXT', theChosenFile.theScript)) == noErr) {
  1245.                 if ((err = FSpOpenDFCompat(&theChosenFile.destFile, fsWrPerm, &tmpFRefN)) == noErr) {
  1246. // 6
  1247.                     HLockHi(regText);
  1248.                     myPB.ioParam.ioCompletion = nil;
  1249.                     myPB.ioParam.ioBuffer = *regText;
  1250.                     myPB.ioParam.ioReqCount = InlineGetHandleSize(regText);
  1251.                     myPB.ioParam.ioPosMode = fsFromStart | kNoCacheMask;
  1252.                     myPB.ioParam.ioRefNum = tmpFRefN;
  1253.                     myPB.ioParam.ioPosOffset = 0L;
  1254.                     (void)PBWriteAsync(&myPB);
  1255.                     while (myPB.ioParam.ioResult > 0) {
  1256.                         SystemTask();
  1257.                         (void)EventAvail(everyEvent, &dummyEv);
  1258.                         }
  1259.                     HUnlock(regText);
  1260.                     (void)FSClose(tmpFRefN);
  1261.                     InitCursor();
  1262.                     MyNumToString(myPB.ioParam.ioResult, tempS);
  1263.                     ParamText(theChosenFile.destFile.name, tempS, nil, nil);
  1264.                     if (myPB.ioParam.ioResult == noErr) {
  1265.                         (void) NoteAlert(kALRT_REGSUCCESSSAVED, nil);
  1266.                         }
  1267.                     else if (myPB.ioParam.ioResult == dskFulErr) {
  1268. // 6
  1269.                         (void) FSpDeleteCompat(&theChosenFile.destFile);
  1270. // 6
  1271.                         (void) StopAlert(kALRT_REGDISKFULL, nil);
  1272.                         }
  1273.                     else
  1274.                         (void) StopAlert(kALRT_REGUNKNOWNWRITEERROR, nil);
  1275.                     }
  1276.                 else
  1277.                     (void) StopAlert(kALRT_REGCOULDNOTOPENFORWRITING, nil);
  1278.                 }
  1279.             else
  1280.                 (void) StopAlert(kALRT_REGCOULDNOTCREATE, nil);
  1281.             DisposeHandle(regText);
  1282.             }
  1283.         }
  1284.     DisposePtr((Ptr)regInfo[0]);
  1285.     }
  1286. else
  1287.     SysBeep(30);
  1288. }
  1289.  
  1290. void CopyBugReportForm(long (*regCfgInfo)(Handle, long, StringPtr))
  1291. {
  1292. enum {
  1293. kMyRegText = 257
  1294. };
  1295.  
  1296. Str63    tempS = "\p";
  1297. long    lOffset;
  1298. Handle    regText;
  1299. VersRecHndl    myvers;
  1300. const char    optspace = 'Δ';
  1301.  
  1302. regText = Get1Resource('TEXT', kMyRegText);
  1303. if (regText) {
  1304.     DetachResource(regText);
  1305.     myvers = (VersRecHndl)Get1Resource('vers', 1);
  1306.     if (myvers) {
  1307.         (void) PLstrcpy(tempS, (*myvers)->shortVersion);
  1308.         ReleaseResource((Handle)myvers);
  1309.         }
  1310.     lOffset = Munger(regText, 0L, &optspace, 1L, &tempS[1], tempS[0]);
  1311.     lOffset = RegisterStdConfigInfo(regText, lOffset, tempS);
  1312.     /* custom configuration */
  1313.     if (regCfgInfo)
  1314.         lOffset = regCfgInfo(regText, lOffset, tempS);
  1315.     if (noErr == ZeroScrap()) {
  1316.         HLockHi(regText);
  1317.         (void) PutScrap(InlineGetHandleSize(regText), 'TEXT', *regText);
  1318.         HUnlock(regText);
  1319.         }
  1320.     (void)TEFromScrap();
  1321.     DisposeHandle(regText);
  1322.     }
  1323. }
  1324.  
  1325. long RegisterStdConfigInfo(Handle regText, long curOffset, StringPtr tempS)
  1326. {
  1327. StringPtr    myAppName = nil;
  1328. long    lOffset = curOffset;
  1329. long    gResp;
  1330. const short    dash = 0x012D;
  1331. const char    optspace = 'Δ';
  1332.  
  1333. /* Mac model */
  1334. if (Gestalt(gestaltMachineType, &gResp) == noErr) {
  1335.     myAppName = GetPtrIndHString(GetResource('STR#', kMachineNameStrID), (unsigned short)(gResp - 1L));
  1336.     lOffset = Munger(regText, lOffset, &optspace, 1L, &myAppName[1], myAppName[0]);
  1337.     }
  1338. else {
  1339.     lOffset = Munger(regText, lOffset, &optspace, 1L, &((char *)&dash)[1], 1L);
  1340.     }
  1341. /* Sys version */
  1342. if (Gestalt(gestaltSystemVersion, &gResp) == noErr) {
  1343.     BCDVersNumToString(gResp, tempS);
  1344.     }
  1345. else {
  1346.     *(short *)tempS = dash;
  1347.     }
  1348. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1349. /* addr mode info */
  1350. if (Gestalt(gestaltAddressingModeAttr, &gResp) == noErr) {
  1351.     MyNumToString(gResp, tempS);
  1352.     }
  1353. else {
  1354.     *(short *)tempS = dash;
  1355.     }
  1356. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1357. /* A/UX info */
  1358. if (Gestalt(gestaltAUXVersion, &gResp) == noErr) {
  1359.     BCDVersNumToString(gResp, tempS);
  1360.     }
  1361. else {
  1362.     *(short *)tempS = dash;
  1363.     }
  1364. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1365. /* Hardware info */
  1366. if (Gestalt(gestaltHardwareAttr, &gResp) == noErr) {
  1367.     MyNumToString(gResp, tempS);
  1368.     }
  1369. else {
  1370.     *(short *)tempS = dash;
  1371.     }
  1372. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1373. /* VM info */
  1374. if (Gestalt(gestaltVMAttr, &gResp) == noErr) {
  1375.     MyNumToString(gResp, tempS);
  1376.     }
  1377. else {
  1378.     *(short *)tempS = dash;
  1379.     }
  1380. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1381. /* Power Manager info */
  1382. if (Gestalt(gestaltPowerMgrAttr, &gResp) == noErr) {
  1383.     MyNumToString(gResp, tempS);
  1384.     }
  1385. else {
  1386.     *(short *)tempS = dash;
  1387.     }
  1388. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1389. /* Processor type info */
  1390. if (Gestalt(gestaltProcessorType, &gResp) == noErr) {
  1391.     MyNumToString(gResp, tempS);
  1392.     }
  1393. else {
  1394.     *(short *)tempS = dash;
  1395.     }
  1396. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1397. /* System architecture info */
  1398. if (Gestalt(gestaltSysArchitecture, &gResp) == noErr) {
  1399.     MyNumToString(gResp, tempS);
  1400.     }
  1401. else {
  1402.     *(short *)tempS = dash;
  1403.     }
  1404. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1405. /* Native processor info */
  1406. if (Gestalt(gestaltNativeCPUtype, &gResp) == noErr) {
  1407.     MyNumToString(gResp, tempS);
  1408.     }
  1409. else {
  1410.     *(short *)tempS = dash;
  1411.     }
  1412. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1413. /* System 7 tuner info */
  1414. if (Gestalt('bugz', &gResp) == noErr) {
  1415.     MyNumToString(gResp, tempS);
  1416.     }
  1417. else {
  1418.     *(short *)tempS = dash;
  1419.     }
  1420. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1421. /* Hardware System Updater info */
  1422. if (Gestalt('bugy', &gResp) == noErr) {
  1423.     MyNumToString(gResp, tempS);
  1424.     }
  1425. else {
  1426.     *(short *)tempS = dash;
  1427.     }
  1428. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1429. /* Hardware System Updater 3 info */
  1430. if (Gestalt('bugx', &gResp) == noErr) {
  1431.     MyNumToString(gResp, tempS);
  1432.     }
  1433. else {
  1434.     *(short *)tempS = dash;
  1435.     }
  1436. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1437. /* AppleScript info */
  1438. if (Gestalt(gestaltAppleScriptVersion, &gResp) == noErr) {
  1439.     BCDLongVersNumToString(gResp, tempS);
  1440.     }
  1441. else {
  1442.     *(short *)tempS = dash;
  1443.     }
  1444. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1445. /* QuickTime info */
  1446. if (Gestalt(gestaltQuickTimeVersion, &gResp) == noErr) {
  1447.     BCDLongVersNumToString(gResp, tempS);
  1448.     }
  1449. else {
  1450.     *(short *)tempS = dash;
  1451.     }
  1452. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1453. /* Thread Manager info */
  1454. if (Gestalt(gestaltThreadMgrAttr, &gResp) == noErr) {
  1455.     MyNumToString(gResp, tempS);
  1456.     }
  1457. else {
  1458.     *(short *)tempS = dash;
  1459.     }
  1460. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1461. /* Display Manager attr */
  1462. if (Gestalt(gestaltDisplayMgrAttr, &gResp) == noErr) {
  1463.     MyNumToString(gResp, tempS);
  1464.     }
  1465. else {
  1466.     *(short *)tempS = dash;
  1467.     }
  1468. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1469. /* Display Manager version */
  1470. if (Gestalt(gestaltDisplayMgrVers, &gResp) == noErr) {
  1471.     MyNumToString(gResp, tempS);
  1472.     }
  1473. else {
  1474.     *(short *)tempS = dash;
  1475.     }
  1476. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1477. /* Drag Manager attr */
  1478. if (Gestalt(gestaltDragMgrAttr, &gResp) == noErr) {
  1479.     MyNumToString(gResp, tempS);
  1480.     }
  1481. else {
  1482.     *(short *)tempS = dash;
  1483.     }
  1484. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1485. /* AE attr */
  1486. if (Gestalt(gestaltAppleEventsAttr, &gResp) == noErr) {
  1487.     MyNumToString(gResp, tempS);
  1488.     }
  1489. else {
  1490.     *(short *)tempS = dash;
  1491.     }
  1492. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1493. /* Finder attr */
  1494. if (Gestalt(gestaltFinderAttr, &gResp) == noErr) {
  1495.     MyNumToString(gResp, tempS);
  1496.     }
  1497. else {
  1498.     *(short *)tempS = dash;
  1499.     }
  1500. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1501. /* FS attr */
  1502. if (Gestalt(gestaltFSAttr, &gResp) == noErr) {
  1503.     MyNumToString(gResp, tempS);
  1504.     }
  1505. else {
  1506.     *(short *)tempS = dash;
  1507.     }
  1508. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1509. /* OS attr */
  1510. if (Gestalt(gestaltOSAttr, &gResp) == noErr) {
  1511.     MyNumToString(gResp, tempS);
  1512.     }
  1513. else {
  1514.     *(short *)tempS = dash;
  1515.     }
  1516. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1517. /* Standard File attr */
  1518. if (Gestalt(gestaltStandardFileAttr, &gResp) == noErr) {
  1519.     MyNumToString(gResp, tempS);
  1520.     }
  1521. else {
  1522.     *(short *)tempS = dash;
  1523.     }
  1524. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1525. /* TextEdit attr */
  1526. if (Gestalt(gestaltTEAttr, &gResp) == noErr) {
  1527.     MyNumToString(gResp, tempS);
  1528.     }
  1529. else {
  1530.     *(short *)tempS = dash;
  1531.     }
  1532. lOffset = Munger(regText, lOffset, &optspace, 1L, &tempS[1], tempS[0]);
  1533.  
  1534. return lOffset;
  1535. }
  1536.  
  1537. void RegInitProc(DialogPtr myDPtr)
  1538. {
  1539. Str255    textStr, discountStr;
  1540. Rect    iRect;
  1541. //GrafPtr    savePort;
  1542. Handle    iHandle;
  1543. long    qty;
  1544. short    iType;
  1545. //register RgnHandle    updtRgn;
  1546.  
  1547. GetDialogItem(myDPtr, kItemQuantity, &iType, &iHandle, &iRect);
  1548. GetDialogItemText(iHandle, textStr);
  1549. StringToNum(textStr, &qty);
  1550. MyNumToString(gHowManyDollars * qty, textStr);
  1551. MyNumToString(gHowManyDollars * sqrt(qty), discountStr);
  1552. //UnloadSeg(sqrt);
  1553. ParamText(nil, textStr, discountStr, nil);
  1554. GetDialogItem(myDPtr, kItemTotals, &iType, &iHandle, &iRect);
  1555. // correggere con InvalRect !!!!
  1556. /*updtRgn = NewRgn();
  1557. if (updtRgn) {
  1558.     RectRgn(updtRgn, &iRect);
  1559.     UpdtDialog(myDPtr, updtRgn);
  1560.     DisposeRgn(updtRgn);
  1561.     }
  1562. */
  1563. //GetPort(&savePort);
  1564. //SetPort(myDPtr);
  1565. //DebugStr("\pInvalRect imminent");
  1566. InvalRect(&iRect);
  1567. //SetPort(savePort);
  1568. }
  1569.  
  1570. OSErr AskForDestFile(StdFileResultPtr whichFile, ConstStr255Param prompt, StringPtr docName)
  1571. {
  1572. StandardFileReply    mySFR;
  1573. register Handle    sH1;
  1574. register Handle    sH2;
  1575. register SignedByte    state1, state2;
  1576. register OSErr    err = userCanceledErr;
  1577.  
  1578. // 6
  1579. FabStandardPutFile(prompt ? prompt : (sH1 = (Handle)GetString(kSTR_RegPROMPT),
  1580.                                         state1 = WantThisHandleSafe(sH1),
  1581.                                         (ConstStr255Param)*sH1),
  1582.                 docName ? docName : (sH2 = (Handle)GetString(kSTR_RegDEFNAME),
  1583.                                     state2 = WantThisHandleSafe(sH2),
  1584.                                     (ConstStr255Param)*sH2),
  1585.                 &mySFR);
  1586. // 6
  1587.  
  1588. if (docName == nil)
  1589.     HSetState(sH2, state2);
  1590. if (prompt == nil)
  1591.     HSetState(sH1, state1);
  1592.  
  1593. if (mySFR.sfGood) {
  1594.     if (mySFR.sfReplacing)
  1595.         err = dupFNErr;
  1596.     else {
  1597.         err = noErr;
  1598.         whichFile->destFile = mySFR.sfFile;
  1599.         whichFile->theScript = mySFR.sfScript;
  1600.         if (docName)
  1601.             (void) PLstrncpy(docName, mySFR.sfFile.name, 31);
  1602.         }
  1603.     }
  1604. return err;
  1605. }
  1606.  
  1607. void BCDVersNumToString(long num, StringPtr str)
  1608. {
  1609. Str15    tmpstr;
  1610. const short    onepoint = 0x012E;
  1611. register long    tmp;
  1612.  
  1613. str[0] = 0;
  1614. tmp = num;
  1615. tmp >>= 8;
  1616. tmp &= 0xFF;
  1617. MyNumToString(tmp, str);
  1618. (void) PLstrcat(str, (StringPtr)&onepoint);
  1619. tmp = num;
  1620. tmp >>= 4;
  1621. tmp &= 0xF;
  1622. MyNumToString(tmp, tmpstr);
  1623. (void) PLstrcat(str, (StringPtr)&tmpstr);
  1624. tmp = num;
  1625. tmp &= 0xF;
  1626. if (tmp) {
  1627.     MyNumToString(tmp, tmpstr);
  1628.     (void) PLstrcat(str, (StringPtr)&onepoint);
  1629.     (void) PLstrcat(str, (StringPtr)&tmpstr);
  1630.     }
  1631. }
  1632.  
  1633. void BCDLongVersNumToString(long num, StringPtr str)
  1634. {
  1635. Str15    tmpstr;
  1636. const short    onepoint = 0x012E;
  1637. const short    devStr = 0x0164;
  1638. const short    alphaStr = 0x0161;
  1639. const short    betaStr = 0x0162;
  1640. const short    releaseStr = 0x0172;
  1641. register long    tmp;
  1642.  
  1643. str[0] = 0;
  1644. tmp = num;
  1645. tmp >>= 24;
  1646. tmp &= 0xFF;
  1647. MyNumToString(tmp, str);
  1648. (void) PLstrcat(str, (StringPtr)&onepoint);
  1649. tmp = num;
  1650. tmp >>= 20;
  1651. tmp &= 0xF;
  1652. MyNumToString(tmp, tmpstr);
  1653. (void) PLstrcat(str, (StringPtr)&tmpstr);
  1654. tmp = num;
  1655. tmp >>= 16;
  1656. tmp &= 0xF;
  1657. if (tmp) {
  1658.     MyNumToString(tmp, tmpstr);
  1659.     (void) PLstrcat(str, (StringPtr)&onepoint);
  1660.     (void) PLstrcat(str, (StringPtr)&tmpstr);
  1661.     }
  1662. tmp = num;
  1663. tmp >>= 8;
  1664. tmp &= 0xFF;
  1665. switch (tmp) {
  1666.     case developStage:
  1667.         (void) PLstrcat(str, (StringPtr)&devStr);
  1668.         break;
  1669.     case alphaStage:
  1670.         (void) PLstrcat(str, (StringPtr)&alphaStr);
  1671.         break;
  1672.     case betaStage:
  1673.         (void) PLstrcat(str, (StringPtr)&betaStr);
  1674.         break;
  1675.     case finalStage:
  1676.         (void) PLstrcat(str, (StringPtr)&releaseStr);
  1677.         break;
  1678.     }
  1679. tmp = num;
  1680. tmp &= 0xFF;
  1681. if (tmp) {
  1682.     MyNumToString(tmp, tmpstr);
  1683.     (void) PLstrcat(str, (StringPtr)&tmpstr);
  1684.     }
  1685. }
  1686.  
  1687. #if    !defined(FabNoSegmentDirectives)
  1688. #pragma segment Init
  1689. #endif
  1690.  
  1691. /* Code from Apple® converted by Stefan Kurth in super-optimized (!) C */
  1692.  
  1693. /* InitGraf is always implemented (trap $A86E). If the trap table is big
  1694.   enough, trap $AA6E will always point to either Unimplemented or some other
  1695.   trap, but will never be the same as InitGraf. Thus, you can check the size
  1696.   of the trap table by asking if the address of trap $A86E is the same as
  1697.   $AA6E. */
  1698.  
  1699. #define NumToolboxTraps    ((GetToolTrapAddress(_InitGraf) == GetToolTrapAddress(0xAA6E)) ? 0x0200 : 0x0400)
  1700.  
  1701. /* Determines the type of a trap based on its trap number. If bit 11 is clear,
  1702.   then it is an OS trap. Otherwise, it is a Toolbox trap. */
  1703. /* OS traps start with A0, Tool with A8 or AA. */
  1704.  
  1705. #define GetTrapType(which)    (((which) & 0x0800) ? ToolTrap : OSTrap)
  1706. #define IsToolTrap(trap)    ((trap) & 0x0800)
  1707.  
  1708. /* Check to see if a given trap is implemented. This is only used by the
  1709.   Initialize routine in this program, so we put it in the Initialize segment.*/
  1710.  
  1711. Boolean TrapAvailable(short theTrap)
  1712. {
  1713. register UniversalProcPtr    theTrapAddress;
  1714. register short    temp;
  1715.  
  1716. temp = theTrap;
  1717. if(IsToolTrap(temp)) {
  1718.     temp &= 0x07FF;
  1719.     if( temp >= NumToolboxTraps)
  1720.         return false;
  1721.     theTrapAddress = GetToolTrapAddress(temp);
  1722.     }
  1723. else
  1724.     theTrapAddress = GetOSTrapAddress(temp);
  1725. return( GetToolTrapAddress(_Unimplemented) != theTrapAddress);
  1726. }
  1727.  
  1728. OSErr InstallRequiredAEHandlers(AEEventHandlerProcPtr myOAPP,
  1729.                                 AEEventHandlerProcPtr myODOC,
  1730.                                 AEEventHandlerProcPtr myPDOC,
  1731.                                 AEEventHandlerProcPtr myQUIT)
  1732. {
  1733. OSErr    err;
  1734.  
  1735. gmyOAPP_UPP = NewAEEventHandlerProc(myOAPP);
  1736. gmyODOC_UPP = NewAEEventHandlerProc(myODOC);
  1737. gmyPDOC_UPP = NewAEEventHandlerProc(myPDOC);
  1738. gmyQUIT_UPP = NewAEEventHandlerProc(myQUIT);
  1739. if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, gmyOAPP_UPP, 0, false)))
  1740.     if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, gmyODOC_UPP, 0, false)))
  1741.         if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, gmyPDOC_UPP, 0, false)))
  1742.             if(noErr == (err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, gmyQUIT_UPP, 0, false)))
  1743.                 ;
  1744.  
  1745. return err;
  1746. }
  1747.  
  1748. #endif
  1749.  
  1750.